/*
 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
/*
 * Copyright 1999-2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.sun.org.apache.xerces.internal.impl.dv.xs;

import java.math.BigDecimal;

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.Duration;
import javax.xml.datatype.XMLGregorianCalendar;

import com.sun.org.apache.xerces.internal.impl.Constants;
import com.sun.org.apache.xerces.internal.jaxp.datatype.DatatypeFactoryImpl;
import com.sun.org.apache.xerces.internal.xs.datatypes.XSDateTime;

/**
 * This is the base class of all date/time datatype validators.
 * It implements common code for parsing, validating and comparing datatypes.
 * Classes that extend this class, must implement parse() method.
 *
 * REVISIT: There are many instance variables, which would cause problems
 * when we support grammar caching. A grammar is possibly used by
 * two parser instances at the same time, then the same simple type
 * decl object can be used to validate two strings at the same time.
 * -SG
 *
 * @author Elena Litani
 * @author Len Berman
 * @author Gopal Sharma, SUN Microsystems Inc.
 * @version $Id: AbstractDateTimeDV.java,v 1.7 2010-11-01 04:39:46 joehw Exp $
 * @xerces.internal
 */
public abstract class AbstractDateTimeDV extends TypeValidator {

  //debugging
  private static final boolean DEBUG = false;
  //define shared variables for date/time
  //define constants to be used in assigning default values for
  //all date/time excluding duration
  protected final static int YEAR = 2000;
  protected final static int MONTH = 01;
  protected final static int DAY = 01;
  protected static final DatatypeFactory datatypeFactory = new DatatypeFactoryImpl();

  @Override
  public short getAllowedFacets() {
    return (XSSimpleTypeDecl.FACET_PATTERN | XSSimpleTypeDecl.FACET_WHITESPACE
        | XSSimpleTypeDecl.FACET_ENUMERATION | XSSimpleTypeDecl.FACET_MAXINCLUSIVE
        | XSSimpleTypeDecl.FACET_MININCLUSIVE | XSSimpleTypeDecl.FACET_MAXEXCLUSIVE
        | XSSimpleTypeDecl.FACET_MINEXCLUSIVE);
  }//getAllowedFacets()

  // distinguishes between identity and equality for date/time values
  // ie: two values representing the same "moment in time" but with different
  // remembered timezones are now equal but not identical.
  @Override
  public boolean isIdentical(Object value1, Object value2) {
    if (!(value1 instanceof DateTimeData) || !(value2 instanceof DateTimeData)) {
      return false;
    }

    DateTimeData v1 = (DateTimeData) value1;
    DateTimeData v2 = (DateTimeData) value2;

    // original timezones must be the same in addition to date/time values
    // being 'equal'
    if ((v1.timezoneHr == v2.timezoneHr) && (v1.timezoneMin == v2.timezoneMin)) {
      return v1.equals(v2);
    }

    return false;
  }//isIdentical()

  // the parameters are in compiled form (from getActualValue)
  @Override
  public int compare(Object value1, Object value2) {
    return compareDates(((DateTimeData) value1),
        ((DateTimeData) value2), true);
  }//compare()

  /**
   * Compare algorithm described in dateDime (3.2.7). Duration datatype
   * overwrites this method
   *
   * @param date1 normalized date representation of the first value
   * @param date2 normalized date representation of the second value
   * @return less, greater, less_equal, greater_equal, equal
   */
  protected short compareDates(DateTimeData date1, DateTimeData date2, boolean strict) {
    if (date1.utc == date2.utc) {
      return compareOrder(date1, date2);
    }
    short c1, c2;

    DateTimeData tempDate = new DateTimeData(null, this);

    if (date1.utc == 'Z') {

      //compare date1<=date1<=(date2 with time zone -14)
      //
      cloneDate(date2, tempDate); //clones date1 value to global temporary storage: fTempDate
      tempDate.timezoneHr = 14;
      tempDate.timezoneMin = 0;
      tempDate.utc = '+';
      normalize(tempDate);
      c1 = compareOrder(date1, tempDate);
      if (c1 == LESS_THAN) {
        return c1;
      }

      //compare date1>=(date2 with time zone +14)
      //
      cloneDate(date2, tempDate); //clones date1 value to global temporary storage: tempDate
      tempDate.timezoneHr = -14;
      tempDate.timezoneMin = 0;
      tempDate.utc = '-';
      normalize(tempDate);
      c2 = compareOrder(date1, tempDate);
      if (c2 == GREATER_THAN) {
        return c2;
      }

      return INDETERMINATE;
    } else if (date2.utc == 'Z') {

      //compare (date1 with time zone -14)<=date2
      //
      cloneDate(date1, tempDate); //clones date1 value to global temporary storage: tempDate
      tempDate.timezoneHr = -14;
      tempDate.timezoneMin = 0;
      tempDate.utc = '-';
      if (DEBUG) {
        System.out.println("tempDate=" + dateToString(tempDate));
      }
      normalize(tempDate);
      c1 = compareOrder(tempDate, date2);
      if (DEBUG) {
        System.out.println("date=" + dateToString(date2));
        System.out.println("tempDate=" + dateToString(tempDate));
      }
      if (c1 == LESS_THAN) {
        return c1;
      }

      //compare (date1 with time zone +14)<=date2
      //
      cloneDate(date1, tempDate); //clones date1 value to global temporary storage: tempDate
      tempDate.timezoneHr = 14;
      tempDate.timezoneMin = 0;
      tempDate.utc = '+';
      normalize(tempDate);
      c2 = compareOrder(tempDate, date2);
      if (DEBUG) {
        System.out.println("tempDate=" + dateToString(tempDate));
      }
      if (c2 == GREATER_THAN) {
        return c2;
      }

      return INDETERMINATE;
    }
    return INDETERMINATE;

  }

  /**
   * Given normalized values, determines order-relation between give date/time
   * objects.
   *
   * @param date1 date/time object
   * @param date2 date/time object
   * @return 0 if date1 and date2 are equal, a value less than 0 if date1 is less than date2, a
   * value greater than 0 if date1 is greater than date2
   */
  protected short compareOrder(DateTimeData date1, DateTimeData date2) {
    if (date1.position < 1) {
      if (date1.year < date2.year) {
        return -1;
      }
      if (date1.year > date2.year) {
        return 1;
      }
    }
    if (date1.position < 2) {
      if (date1.month < date2.month) {
        return -1;
      }
      if (date1.month > date2.month) {
        return 1;
      }
    }
    if (date1.day < date2.day) {
      return -1;
    }
    if (date1.day > date2.day) {
      return 1;
    }
    if (date1.hour < date2.hour) {
      return -1;
    }
    if (date1.hour > date2.hour) {
      return 1;
    }
    if (date1.minute < date2.minute) {
      return -1;
    }
    if (date1.minute > date2.minute) {
      return 1;
    }
    if (date1.second < date2.second) {
      return -1;
    }
    if (date1.second > date2.second) {
      return 1;
    }
    if (date1.utc < date2.utc) {
      return -1;
    }
    if (date1.utc > date2.utc) {
      return 1;
    }
    return 0;
  }

  /**
   * Parses time hh:mm:ss.sss and time zone if any
   */
  protected void getTime(String buffer, int start, int end, DateTimeData data)
      throws RuntimeException {

    int stop = start + 2;

    //get hours (hh)
    data.hour = parseInt(buffer, start, stop);

    //get minutes (mm)

    if (buffer.charAt(stop++) != ':') {
      throw new RuntimeException("Error in parsing time zone");
    }
    start = stop;
    stop = stop + 2;
    data.minute = parseInt(buffer, start, stop);

    //get seconds (ss)
    if (buffer.charAt(stop++) != ':') {
      throw new RuntimeException("Error in parsing time zone");
    }

    //find UTC sign if any
    int sign = findUTCSign(buffer, start, end);

    //get seconds (ms)
    start = stop;
    stop = sign < 0 ? end : sign;
    data.second = parseSecond(buffer, start, stop);

    //parse UTC time zone (hh:mm)
    if (sign > 0) {
      getTimeZone(buffer, data, sign, end);
    }
  }

  /**
   * Parses date CCYY-MM-DD
   *
   * @param start start position
   * @param end end position
   */
  protected int getDate(String buffer, int start, int end, DateTimeData date)
      throws RuntimeException {

    start = getYearMonth(buffer, start, end, date);

    if (buffer.charAt(start++) != '-') {
      throw new RuntimeException("CCYY-MM must be followed by '-' sign");
    }
    int stop = start + 2;
    date.day = parseInt(buffer, start, stop);
    return stop;
  }

  /**
   * Parses date CCYY-MM
   *
   * @param start start position
   * @param end end position
   */
  protected int getYearMonth(String buffer, int start, int end, DateTimeData date)
      throws RuntimeException {

    if (buffer.charAt(0) == '-') {
      // REVISIT: date starts with preceding '-' sign
      //          do we have to do anything with it?
      //
      start++;
    }
    int i = indexOf(buffer, start, end, '-');
    if (i == -1) {
      throw new RuntimeException("Year separator is missing or misplaced");
    }
    int length = i - start;
    if (length < 4) {
      throw new RuntimeException("Year must have 'CCYY' format");
    } else if (length > 4 && buffer.charAt(start) == '0') {
      throw new RuntimeException(
          "Leading zeros are required if the year value would otherwise have fewer than four digits; otherwise they are forbidden");
    }
    date.year = parseIntYear(buffer, i);
    if (buffer.charAt(i) != '-') {
      throw new RuntimeException("CCYY must be followed by '-' sign");
    }
    start = ++i;
    i = start + 2;
    date.month = parseInt(buffer, start, i);
    return i; //fStart points right after the MONTH
  }

  /**
   * Shared code from Date and YearMonth datatypes. Finds if time zone sign is
   * present
   */
  protected void parseTimeZone(String buffer, int start, int end, DateTimeData date)
      throws RuntimeException {

    //fStart points right after the date

    if (start < end) {
      if (!isNextCharUTCSign(buffer, start, end)) {
        throw new RuntimeException("Error in month parsing");
      } else {
        getTimeZone(buffer, date, start, end);
      }
    }
  }

  /**
   * Parses time zone: 'Z' or {+,-} followed by hh:mm
   */
  protected void getTimeZone(String buffer, DateTimeData data, int sign, int end)
      throws RuntimeException {
    data.utc = buffer.charAt(sign);

    if (buffer.charAt(sign) == 'Z') {
      if (end > (++sign)) {
        throw new RuntimeException("Error in parsing time zone");
      }
      return;
    }
    if (sign <= (end - 6)) {

      int negate = buffer.charAt(sign) == '-' ? -1 : 1;
      //parse hr
      int stop = ++sign + 2;
      data.timezoneHr = negate * parseInt(buffer, sign, stop);
      if (buffer.charAt(stop++) != ':') {
        throw new RuntimeException("Error in parsing time zone");
      }

      //parse min
      data.timezoneMin = negate * parseInt(buffer, stop, stop + 2);

      if (stop + 2 != end) {
        throw new RuntimeException("Error in parsing time zone");
      }
      if (data.timezoneHr != 0 || data.timezoneMin != 0) {
        data.normalized = false;
      }
    } else {
      throw new RuntimeException("Error in parsing time zone");
    }
    if (DEBUG) {
      System.out.println("time[hh]=" + data.timezoneHr + " time[mm]=" + data.timezoneMin);
    }
  }

  /**
   * Computes index of given char within StringBuffer
   *
   * @param ch character to look for in StringBuffer
   * @return index of ch within StringBuffer
   */
  protected int indexOf(String buffer, int start, int end, char ch) {
    for (int i = start; i < end; i++) {
      if (buffer.charAt(i) == ch) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Validates given date/time object accoring to W3C PR Schema [D.1 ISO 8601
   * Conventions]
   */
  protected void validateDateTime(DateTimeData data) {

    //REVISIT: should we throw an exception for not valid dates
    //          or reporting an error message should be sufficient?

    /**
     * XML Schema 1.1 - RQ-123: Allow year 0000 in date related types.
     */
    if (!Constants.SCHEMA_1_1_SUPPORT && data.year == 0) {
      throw new RuntimeException("The year \"0000\" is an illegal year value");

    }

    if (data.month < 1 || data.month > 12) {
      throw new RuntimeException("The month must have values 1 to 12");

    }

    //validate days
    if (data.day > maxDayInMonthFor(data.year, data.month) || data.day < 1) {
      throw new RuntimeException("The day must have values 1 to 31");
    }

    //validate hours
    if (data.hour > 23 || data.hour < 0) {
      if (data.hour == 24 && data.minute == 0 && data.second == 0) {
        data.hour = 0;
        if (++data.day > maxDayInMonthFor(data.year, data.month)) {
          data.day = 1;
          if (++data.month > 12) {
            data.month = 1;
            if (Constants.SCHEMA_1_1_SUPPORT) {
              ++data.year;
            } else if (++data.year == 0) {
              data.year = 1;
            }
          }
        }
      } else {
        throw new RuntimeException("Hour must have values 0-23, unless 24:00:00");
      }
    }

    //validate
    if (data.minute > 59 || data.minute < 0) {
      throw new RuntimeException("Minute must have values 0-59");
    }

    //validate
    if (data.second >= 60 || data.second < 0) {
      throw new RuntimeException("Second must have values 0-59");

    }

    //validate
    if (data.timezoneHr > 14 || data.timezoneHr < -14) {
      throw new RuntimeException("Time zone should have range -14:00 to +14:00");
    } else {
      if ((data.timezoneHr == 14 || data.timezoneHr == -14) && data.timezoneMin != 0) {
        throw new RuntimeException("Time zone should have range -14:00 to +14:00");
      } else if (data.timezoneMin > 59 || data.timezoneMin < -59) {
        throw new RuntimeException("Minute must have values 0-59");
      }
    }

  }

  /**
   * Return index of UTC char: 'Z', '+', '-'
   *
   * @return index of the UTC character that was found
   */
  protected int findUTCSign(String buffer, int start, int end) {
    int c;
    for (int i = start; i < end; i++) {
      c = buffer.charAt(i);
      if (c == 'Z' || c == '+' || c == '-') {
        return i;
      }

    }
    return -1;
  }

  /**
   * Returns
   * <code>true</code> if the character at start is 'Z', '+' or '-'.
   */
  protected final boolean isNextCharUTCSign(String buffer, int start, int end) {
    if (start < end) {
      char c = buffer.charAt(start);
      return (c == 'Z' || c == '+' || c == '-');
    }
    return false;
  }

  /**
   * Given start and end position, parses string value
   *
   * @param buffer string to parse
   * @param start start position
   * @param end end position
   * @return return integer representation of characters
   */
  protected int parseInt(String buffer, int start, int end)
      throws NumberFormatException {
    //REVISIT: more testing on this parsing needs to be done.
    int radix = 10;
    int result = 0;
    int digit = 0;
    int limit = -Integer.MAX_VALUE;
    int multmin = limit / radix;
    int i = start;
    do {
      digit = getDigit(buffer.charAt(i));
      if (digit < 0) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      if (result < multmin) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      result *= radix;
      if (result < limit + digit) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      result -= digit;

    } while (++i < end);
    return -result;
  }

  // parse Year differently to support negative value.
  protected int parseIntYear(String buffer, int end) {
    int radix = 10;
    int result = 0;
    boolean negative = false;
    int i = 0;
    int limit;
    int multmin;
    int digit = 0;

    if (buffer.charAt(0) == '-') {
      negative = true;
      limit = Integer.MIN_VALUE;
      i++;

    } else {
      limit = -Integer.MAX_VALUE;
    }
    multmin = limit / radix;
    while (i < end) {
      digit = getDigit(buffer.charAt(i++));
      if (digit < 0) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      if (result < multmin) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      result *= radix;
      if (result < limit + digit) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
      result -= digit;
    }

    if (negative) {
      if (i > 1) {
        return result;
      } else {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
    }
    return -result;

  }

  /**
   * If timezone present - normalize dateTime [E Adding durations to
   * dateTimes]
   *
   * @param date CCYY-MM-DDThh:mm:ss+03
   */
  protected void normalize(DateTimeData date) {

    // REVISIT: we have common code in addDuration() for durations
    //          should consider reorganizing it.
    //

    //add minutes (from time zone)
    int negate = -1;

    if (DEBUG) {
      System.out.println("==>date.minute" + date.minute);
      System.out.println("==>date.timezoneMin" + date.timezoneMin);
    }
    int temp = date.minute + negate * date.timezoneMin;
    int carry = fQuotient(temp, 60);
    date.minute = mod(temp, 60, carry);

    if (DEBUG) {
      System.out.println("==>carry: " + carry);
    }
    //add hours
    temp = date.hour + negate * date.timezoneHr + carry;
    carry = fQuotient(temp, 24);
    date.hour = mod(temp, 24, carry);
    if (DEBUG) {
      System.out.println("==>date.hour" + date.hour);
      System.out.println("==>carry: " + carry);
    }

    date.day = date.day + carry;

    while (true) {
      temp = maxDayInMonthFor(date.year, date.month);
      if (date.day < 1) {
        date.day = date.day + maxDayInMonthFor(date.year, date.month - 1);
        carry = -1;
      } else if (date.day > temp) {
        date.day = date.day - temp;
        carry = 1;
      } else {
        break;
      }
      temp = date.month + carry;
      date.month = modulo(temp, 1, 13);
      date.year = date.year + fQuotient(temp, 1, 13);
      if (date.year == 0 && !Constants.SCHEMA_1_1_SUPPORT) {
        date.year = (date.timezoneHr < 0 || date.timezoneMin < 0) ? 1 : -1;
      }
    }
    date.utc = 'Z';
  }

  /**
   * @param date
   */
  protected void saveUnnormalized(DateTimeData date) {
    date.unNormYear = date.year;
    date.unNormMonth = date.month;
    date.unNormDay = date.day;
    date.unNormHour = date.hour;
    date.unNormMinute = date.minute;
    date.unNormSecond = date.second;
  }

  /**
   * Resets object representation of date/time
   *
   * @param data date/time object
   */
  protected void resetDateObj(DateTimeData data) {
    data.year = 0;
    data.month = 0;
    data.day = 0;
    data.hour = 0;
    data.minute = 0;
    data.second = 0;
    data.utc = 0;
    data.timezoneHr = 0;
    data.timezoneMin = 0;
  }

  /**
   * Given {year,month} computes maximum number of days for given month
   *
   * @return integer containg the number of days in a given month
   */
  protected int maxDayInMonthFor(int year, int month) {
    //validate days
    if (month == 4 || month == 6 || month == 9 || month == 11) {
      return 30;
    } else if (month == 2) {
      if (isLeapYear(year)) {
        return 29;
      } else {
        return 28;
      }
    } else {
      return 31;
    }
  }

  private boolean isLeapYear(int year) {

    //REVISIT: should we take care about Julian calendar?
    return ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)));
  }

  //
  // help function described in W3C PR Schema [E Adding durations to dateTimes]
  //
  protected int mod(int a, int b, int quotient) {
    //modulo(a, b) = a - fQuotient(a,b)*b
    return (a - quotient * b);
  }

  //
  // help function described in W3C PR Schema [E Adding durations to dateTimes]
  //
  protected int fQuotient(int a, int b) {

    //fQuotient(a, b) = the greatest integer less than or equal to a/b
    return (int) Math.floor((float) a / b);
  }

  //
  // help function described in W3C PR Schema [E Adding durations to dateTimes]
  //
  protected int modulo(int temp, int low, int high) {
    //modulo(a - low, high - low) + low
    int a = temp - low;
    int b = high - low;
    return (mod(a, b, fQuotient(a, b)) + low);
  }

  //
  // help function described in W3C PR Schema [E Adding durations to dateTimes]
  //
  protected int fQuotient(int temp, int low, int high) {
    //fQuotient(a - low, high - low)

    return fQuotient(temp - low, high - low);
  }

  protected String dateToString(DateTimeData date) {
    StringBuffer message = new StringBuffer(25);
    append(message, date.year, 4);
    message.append('-');
    append(message, date.month, 2);
    message.append('-');
    append(message, date.day, 2);
    message.append('T');
    append(message, date.hour, 2);
    message.append(':');
    append(message, date.minute, 2);
    message.append(':');
    append(message, date.second);
    append(message, (char) date.utc, 0);
    return message.toString();
  }

  protected final void append(StringBuffer message, int value, int nch) {
    if (value == Integer.MIN_VALUE) {
      message.append(value);
      return;
    }
    if (value < 0) {
      message.append('-');
      value = -value;
    }
    if (nch == 4) {
      if (value < 10) {
        message.append("000");
      } else if (value < 100) {
        message.append("00");
      } else if (value < 1000) {
        message.append('0');
      }
      message.append(value);
    } else if (nch == 2) {
      if (value < 10) {
        message.append('0');
      }
      message.append(value);
    } else {
      if (value != 0) {
        message.append((char) value);
      }
    }
  }

  protected final void append(StringBuffer message, double value) {
    if (value < 0) {
      message.append('-');
      value = -value;
    }
    if (value < 10) {
      message.append('0');
    }
    append2(message, value);
  }

  protected final void append2(StringBuffer message, double value) {
    final int intValue = (int) value;
    if (value == intValue) {
      message.append(intValue);
    } else {
      append3(message, value);
    }
  }

  private void append3(StringBuffer message, double value) {
    String d = String.valueOf(value);
    int eIndex = d.indexOf('E');
    if (eIndex == -1) {
      message.append(d);
      return;
    }
    int exp;
    if (value < 1) {
      // Need to convert from scientific notation of the form
      // n.nnn...E-N (N >= 4) to a normal decimal value.
      try {
        exp = parseInt(d, eIndex + 2, d.length());
      } // This should never happen.
      // It's only possible if String.valueOf(double) is broken.
      catch (Exception e) {
        message.append(d);
        return;
      }
      message.append("0.");
      for (int i = 1; i < exp; ++i) {
        message.append('0');
      }
      // Remove trailing zeros.
      int end = eIndex - 1;
      while (end > 0) {
        char c = d.charAt(end);
        if (c != '0') {
          break;
        }
        --end;
      }
      // Now append the digits to the end. Skip over the decimal point.
      for (int i = 0; i <= end; ++i) {
        char c = d.charAt(i);
        if (c != '.') {
          message.append(c);
        }
      }
    } else {
      // Need to convert from scientific notation of the form
      // n.nnn...EN (N >= 7) to a normal decimal value.
      try {
        exp = parseInt(d, eIndex + 1, d.length());
      } // This should never happen.
      // It's only possible if String.valueOf(double) is broken.
      catch (Exception e) {
        message.append(d);
        return;
      }
      final int integerEnd = exp + 2;
      for (int i = 0; i < eIndex; ++i) {
        char c = d.charAt(i);
        if (c != '.') {
          if (i == integerEnd) {
            message.append('.');
          }
          message.append(c);
        }
      }
      // Append trailing zeroes if necessary.
      for (int i = integerEnd - eIndex; i > 0; --i) {
        message.append('0');
      }
    }
  }

  protected double parseSecond(String buffer, int start, int end)
      throws NumberFormatException {
    int dot = -1;
    for (int i = start; i < end; i++) {
      char ch = buffer.charAt(i);
      if (ch == '.') {
        dot = i;
      } else if (ch > '9' || ch < '0') {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
    }
    if (dot == -1) {
      if (start + 2 != end) {
        throw new NumberFormatException("'" + buffer + "' has wrong format");
      }
    } else if (start + 2 != dot || dot + 1 == end) {
      throw new NumberFormatException("'" + buffer + "' has wrong format");
    }
    return Double.parseDouble(buffer.substring(start, end));
  }

  //
  //Private help functions
  //
  private void cloneDate(DateTimeData finalValue, DateTimeData tempDate) {
    tempDate.year = finalValue.year;
    tempDate.month = finalValue.month;
    tempDate.day = finalValue.day;
    tempDate.hour = finalValue.hour;
    tempDate.minute = finalValue.minute;
    tempDate.second = finalValue.second;
    tempDate.utc = finalValue.utc;
    tempDate.timezoneHr = finalValue.timezoneHr;
    tempDate.timezoneMin = finalValue.timezoneMin;
  }

  /**
   * Represents date time data
   */
  static final class DateTimeData implements XSDateTime {

    int year, month, day, hour, minute, utc;
    double second;
    int timezoneHr, timezoneMin;
    private String originalValue;
    boolean normalized = true;
    int unNormYear;
    int unNormMonth;
    int unNormDay;
    int unNormHour;
    int unNormMinute;
    double unNormSecond;
    // used for comparisons - to decide the 'interesting' portions of
    // a date/time based data type.
    int position;
    // a pointer to the type that was used go generate this data
    // note that this is not the actual simple type, but one of the
    // statically created XXXDV objects, so this won't cause any GC problem.
    final AbstractDateTimeDV type;
    private volatile String canonical;

    public DateTimeData(String originalValue, AbstractDateTimeDV type) {
      this.originalValue = originalValue;
      this.type = type;
    }

    public DateTimeData(int year, int month, int day, int hour, int minute,
        double second, int utc, String originalValue, boolean normalized, AbstractDateTimeDV type) {
      this.year = year;
      this.month = month;
      this.day = day;
      this.hour = hour;
      this.minute = minute;
      this.second = second;
      this.utc = utc;
      this.type = type;
      this.originalValue = originalValue;
    }

    @Override
    public boolean equals(Object obj) {
      if (!(obj instanceof DateTimeData)) {
        return false;
      }
      return type.compareDates(this, (DateTimeData) obj, true) == 0;
    }

    // If two DateTimeData are equals - then they should have the same
    // hashcode. This means we need to convert the date to UTC before
    // we return its hashcode.
    // The DateTimeData is unfortunately mutable - so we cannot
    // cache the result of the conversion...
    //
    @Override
    public int hashCode() {
      final DateTimeData tempDate = new DateTimeData(null, type);
      type.cloneDate(this, tempDate);
      type.normalize(tempDate);
      return type.dateToString(tempDate).hashCode();
    }

    @Override
    public String toString() {
      if (canonical == null) {
        canonical = type.dateToString(this);
      }
      return canonical;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getYear()
         */

    @Override
    public int getYears() {
      if (type instanceof DurationDV) {
        return 0;
      }
      return normalized ? year : unNormYear;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getMonth()
         */

    @Override
    public int getMonths() {
      if (type instanceof DurationDV) {
        return year * 12 + month;
      }
      return normalized ? month : unNormMonth;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getDay()
         */

    @Override
    public int getDays() {
      if (type instanceof DurationDV) {
        return 0;
      }
      return normalized ? day : unNormDay;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getHour()
         */

    @Override
    public int getHours() {
      if (type instanceof DurationDV) {
        return 0;
      }
      return normalized ? hour : unNormHour;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getMinutes()
         */

    @Override
    public int getMinutes() {
      if (type instanceof DurationDV) {
        return 0;
      }
      return normalized ? minute : unNormMinute;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getSeconds()
         */

    @Override
    public double getSeconds() {
      if (type instanceof DurationDV) {
        return day * 24 * 60 * 60 + hour * 60 * 60 + minute * 60 + second;
      }
      return normalized ? second : unNormSecond;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#hasTimeZone()
         */

    @Override
    public boolean hasTimeZone() {
      return utc != 0;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getTimeZoneHours()
         */

    @Override
    public int getTimeZoneHours() {
      return timezoneHr;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getTimeZoneMinutes()
         */

    @Override
    public int getTimeZoneMinutes() {
      return timezoneMin;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getLexicalValue()
         */

    @Override
    public String getLexicalValue() {
      return originalValue;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#normalize()
         */

    @Override
    public XSDateTime normalize() {
      if (!normalized) {
        DateTimeData dt = (DateTimeData) this.clone();
        dt.normalized = true;
        return dt;
      }
      return this;
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#isNormalized()
         */

    @Override
    public boolean isNormalized() {
      return normalized;
    }

    @Override
    public Object clone() {
      DateTimeData dt = new DateTimeData(this.year, this.month, this.day, this.hour,
          this.minute, this.second, this.utc, this.originalValue, this.normalized, this.type);
      dt.canonical = this.canonical;
      dt.position = position;
      dt.timezoneHr = this.timezoneHr;
      dt.timezoneMin = this.timezoneMin;
      dt.unNormYear = this.unNormYear;
      dt.unNormMonth = this.unNormMonth;
      dt.unNormDay = this.unNormDay;
      dt.unNormHour = this.unNormHour;
      dt.unNormMinute = this.unNormMinute;
      dt.unNormSecond = this.unNormSecond;
      return dt;
    }

    /* (non-Javadoc)
     * @see org.apache.xerces.xs.datatypes.XSDateTime#getXMLGregorianCalendar()
     */
    @Override
    public XMLGregorianCalendar getXMLGregorianCalendar() {
      return type.getXMLGregorianCalendar(this);
    }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getDuration()
         */

    @Override
    public Duration getDuration() {
      return type.getDuration(this);
    }
  }

  protected XMLGregorianCalendar getXMLGregorianCalendar(DateTimeData data) {
    return null;
  }

  protected Duration getDuration(DateTimeData data) {
    return null;
  }

  protected final BigDecimal getFractionalSecondsAsBigDecimal(DateTimeData data) {
    final StringBuffer buf = new StringBuffer();
    append3(buf, data.unNormSecond);
    String value = buf.toString();
    final int index = value.indexOf('.');
    if (index == -1) {
      return null;
    }
    value = value.substring(index);
    final BigDecimal _val = new BigDecimal(value);
    if (_val.compareTo(BigDecimal.valueOf(0)) == 0) {
      return null;
    }
    return _val;
  }
}
